GetClientRect (hwnd, &rect);
ScreenToClient (hwnd, &pt);
if (!PtInRect (&rect, pt))
- return _gdk_parent_root;
+ return _gdk_root;
other_window = gdk_win32_handle_table_lookup ((GdkNativeWindow) hwnd);
}
if (other_window == NULL)
- return _gdk_parent_root;
+ return _gdk_root;
return other_window;
}
{
/* Owner doesn't want it, propagate to parent. */
GdkWindow *parent = gdk_window_get_parent (*window);
- if (parent == _gdk_parent_root || parent == NULL)
+ if (parent == _gdk_root || parent == NULL)
{
/* No parent; check if grabbed */
if (grab_window != NULL)
point.x = client_rect.left; /* always 0 */
point.y = client_rect.top;
/* top level windows need screen coords */
- if (gdk_window_get_parent (window) == _gdk_parent_root)
+ if (gdk_window_get_parent (window) == _gdk_root)
{
ClientToScreen (msg->hwnd, &point);
point.x += _gdk_offset_x;
if (current_window != NULL &&
(((GdkWindowObject *) current_window)->event_mask & GDK_LEAVE_NOTIFY_MASK))
{
- synthesize_crossing_events (_gdk_parent_root, GDK_CROSSING_NORMAL, msg);
+ synthesize_crossing_events (_gdk_root, GDK_CROSSING_NORMAL, msg);
}
break;
point.x = client_rect.left; /* always 0 */
point.y = client_rect.top;
/* top level windows need screen coords */
- if (gdk_window_get_parent (window) == _gdk_parent_root)
+ if (gdk_window_get_parent (window) == _gdk_root)
{
ClientToScreen (msg->hwnd, &point);
point.x += _gdk_offset_x;
case WM_DESTROY:
if (window == current_window)
- assign_object (¤t_window, _gdk_parent_root);
+ assign_object (¤t_window, _gdk_root);
if (p_grab_window == window)
gdk_pointer_ungrab (msg->time);
if (k_grab_window == window)
gdk_keyboard_ungrab (msg->time);
- if ((window != NULL) && (_gdk_root_window != msg->hwnd))
+ if ((window != NULL) && (msg->hwnd != GetDesktopWindow ()))
gdk_window_destroy_notify (window);
if (window == NULL || GDK_WINDOW_DESTROYED (window))
static gpointer parent_class = NULL;
+#define WINDOW_IS_TOPLEVEL(window) \
+ (GDK_WINDOW_TYPE (window) != GDK_WINDOW_CHILD && \
+ GDK_WINDOW_TYPE (window) != GDK_WINDOW_FOREIGN)
+
GType
_gdk_window_impl_win32_get_type (void)
{
{
impl->width = 1;
impl->height = 1;
-
+ impl->toplevel_window_type = -1;
impl->hcursor = NULL;
impl->hicon_big = NULL;
impl->hicon_small = NULL;
GdkRectangle rect;
int i;
- impl = GDK_WINDOW_IMPL_WIN32 (((GdkWindowObject *) _gdk_parent_root)->impl);
+ impl = GDK_WINDOW_IMPL_WIN32 (((GdkWindowObject *) _gdk_root)->impl);
rect = _gdk_monitors[0];
for (i = 1; i < _gdk_num_monitors; i++)
gdk_rectangle_union (&rect, _gdk_monitors+i, &rect);
GdkWindowObject *private;
GdkDrawableImplWin32 *draw_impl;
- g_assert (_gdk_parent_root == NULL);
+ g_assert (_gdk_root == NULL);
- _gdk_parent_root = g_object_new (GDK_TYPE_WINDOW, NULL);
- private = (GdkWindowObject *)_gdk_parent_root;
+ _gdk_root = g_object_new (GDK_TYPE_WINDOW, NULL);
+ private = (GdkWindowObject *)_gdk_root;
draw_impl = GDK_DRAWABLE_IMPL_WIN32 (private->impl);
- draw_impl->handle = _gdk_root_window;
+ draw_impl->handle = GetDesktopWindow ();
draw_impl->wrapper = GDK_DRAWABLE (private);
draw_impl->colormap = gdk_colormap_get_system ();
g_object_ref (draw_impl->colormap);
_gdk_window_init_position (GDK_WINDOW (private));
- gdk_win32_handle_table_insert ((HANDLE *) &_gdk_root_window, _gdk_parent_root);
+ gdk_win32_handle_table_insert ((HANDLE *) &draw_impl->handle, _gdk_root);
- GDK_NOTE (MISC, g_print ("_gdk_parent_root=%p\n", GDK_WINDOW_HWND (_gdk_parent_root)));
+ GDK_NOTE (MISC, g_print ("_gdk_root=%p\n", GDK_WINDOW_HWND (_gdk_root)));
}
static const gchar *
if (!parent)
{
screen = gdk_screen_get_default ();
- parent = gdk_screen_get_root_window (screen);
+ parent = _gdk_root;
}
else
screen = gdk_drawable_get_screen (parent);
* of the root window, except for actual creation.
*/
if (GDK_WINDOW_TYPE (parent) == GDK_WINDOW_FOREIGN)
- parent = _gdk_parent_root;
+ parent = _gdk_root;
private->parent = (GdkWindowObject *)parent;
* attributes->window_type for input-only windows
* before
*/
- if (GDK_WINDOW_TYPE (parent) == GDK_WINDOW_ROOT)
+ if (parent == _gdk_root)
private->window_type = GDK_WINDOW_TEMP;
else
private->window_type = GDK_WINDOW_CHILD;
{
case GDK_WINDOW_TOPLEVEL:
case GDK_WINDOW_DIALOG:
- if (GDK_WINDOW_TYPE (parent) != GDK_WINDOW_ROOT)
+ if (parent != _gdk_root)
{
g_warning (G_STRLOC ": Toplevel windows must be created as children\n"
"of a window of type GDK_WINDOW_ROOT or GDK_WINDOW_FOREIGN");
- hparent = _gdk_root_window;
+ hparent = GetDesktopWindow ();
}
/* Children of foreign windows aren't toplevel windows */
if (GDK_WINDOW_TYPE (orig_parent) == GDK_WINDOW_FOREIGN)
case GDK_WINDOW_TEMP:
/* A temp window is not necessarily a top level window */
- dwStyle = (_gdk_parent_root == parent ? WS_POPUP : WS_CHILDWINDOW);
+ dwStyle = (_gdk_root == parent ? WS_POPUP : WS_CHILDWINDOW);
dwStyle |= WS_CLIPCHILDREN | WS_CLIPSIBLINGS;
dwExStyle |= WS_EX_TOOLWINDOW;
offset_x = _gdk_offset_x;
private->parent = gdk_win32_handle_table_lookup ((GdkNativeWindow) parent);
if (!private->parent || GDK_WINDOW_TYPE (private->parent) == GDK_WINDOW_FOREIGN)
- private->parent = (GdkWindowObject *)_gdk_parent_root;
+ private->parent = (GdkWindowObject *)_gdk_root;
private->parent->children = g_list_prepend (private->parent->children, window);
point.x = rect.left;
point.y = rect.right;
ClientToScreen ((HWND) anid, &point);
- if (parent != _gdk_root_window)
+ if (parent != GetDesktopWindow ())
ScreenToClient (parent, &point);
private->x = point.x;
private->y = point.y;
void
_gdk_windowing_window_destroy_foreign (GdkWindow *window)
{
- /* It's somebody else's window, but in our hierarchy,
- * so reparent it to the root window, and then call
- * DestroyWindow() on it.
+ /* It's somebody else's window, but in our hierarchy, so reparent it
+ * to the desktop, and then try to destroy it.
*/
gdk_window_hide (window);
gdk_window_reparent (window, NULL, 0, 0);
- /* Is this too drastic? Many (most?) applications
- * quit if any window receives WM_QUIT I think.
- * OTOH, I don't think foreign windows are much
- * used, so the question is maybe academic.
- */
- PostMessage (GDK_WINDOW_HWND (window), WM_QUIT, 0, 0);
+ PostMessage (GDK_WINDOW_HWND (window), WM_CLOSE, 0, 0);
}
/* This function is called when the window really gone.
* Foreign windows (another app's windows) might be children of our
* windows! Especially in the case of gtkplug/socket.
*/
- if (GetAncestor (GDK_WINDOW_HWND (window), GA_PARENT) != _gdk_root_window)
+ if (GetAncestor (GDK_WINDOW_HWND (window), GA_PARENT) != GetDesktopWindow ())
_gdk_window_move_resize_child (window, x, y, impl->width, impl->height);
else
{
if (private->state & GDK_WINDOW_STATE_FULLSCREEN)
return;
- if (GetAncestor (GDK_WINDOW_HWND (window), GA_PARENT) != _gdk_root_window)
+ if (GetAncestor (GDK_WINDOW_HWND (window), GA_PARENT) != GetDesktopWindow ())
_gdk_window_move_resize_child (window, private->x, private->y, width, height);
else
{
GDK_WINDOW_HWND (window),
width, height, x, y));
- if (GetAncestor (GDK_WINDOW_HWND (window), GA_PARENT) != _gdk_root_window)
+ if (GetAncestor (GDK_WINDOW_HWND (window), GA_PARENT) != GetDesktopWindow ())
_gdk_window_move_resize_child (window, x, y, width, height);
else
{
GdkWindowObject *parent_private;
GdkWindowObject *old_parent_private;
GdkWindowImplWin32 *impl;
+ gboolean was_toplevel;
+ LONG style;
g_return_if_fail (window != NULL);
g_return_if_fail (GDK_IS_WINDOW (window));
g_return_if_fail (new_parent == NULL || GDK_IS_WINDOW (new_parent));
- g_return_if_fail (GDK_WINDOW_TYPE (window) != GDK_WINDOW_ROOT);
+ g_return_if_fail (window != _gdk_root);
if (GDK_WINDOW_DESTROYED (window) ||
(new_parent && GDK_WINDOW_DESTROYED (new_parent)))
}
if (!new_parent)
- new_parent = _gdk_parent_root;
+ new_parent = _gdk_root;
window_private = (GdkWindowObject*) window;
old_parent_private = (GdkWindowObject *) window_private->parent;
parent_private = (GdkWindowObject*) new_parent;
impl = GDK_WINDOW_IMPL_WIN32 (window_private->impl);
- if (!GDK_WINDOW_DESTROYED (window) && !GDK_WINDOW_DESTROYED (new_parent))
- {
- GDK_NOTE (MISC, g_print ("gdk_window_reparent: %p: %p\n",
- GDK_WINDOW_HWND (window),
- GDK_WINDOW_HWND (new_parent)));
+ GDK_NOTE (MISC, g_print ("gdk_window_reparent: %p: %p\n",
+ GDK_WINDOW_HWND (window),
+ GDK_WINDOW_HWND (new_parent)));
- API_CALL (SetParent, (GDK_WINDOW_HWND (window),
- GDK_WINDOW_HWND (new_parent)));
+ style = GetWindowLong (GDK_WINDOW_HWND (window), GWL_STYLE);
- API_CALL (MoveWindow, (GDK_WINDOW_HWND (window),
- x, y, impl->width, impl->height, TRUE));
+ was_toplevel = GetAncestor (GDK_WINDOW_HWND (window), GA_PARENT) == GetDesktopWindow ();
+ if (was_toplevel && new_parent != _gdk_root)
+ {
+ /* Reparenting from top-level (child of desktop). Clear out
+ * decorations.
+ */
+ style &= ~(WS_OVERLAPPED | WS_CAPTION | WS_SYSMENU | WS_THICKFRAME | WS_MINIMIZEBOX | WS_MAXIMIZEBOX);
+ style |= WS_CHILD;
+ SetWindowLong (GDK_WINDOW_HWND (window), GWL_STYLE, style);
+ }
+ else if (new_parent == _gdk_root)
+ {
+ /* Reparenting to top-level. Add decorations. */
+ style &= ~(WS_CHILD);
+ style |= WS_OVERLAPPEDWINDOW;
+ SetWindowLong (GDK_WINDOW_HWND (window), GWL_STYLE, style);
}
+ API_CALL (SetParent, (GDK_WINDOW_HWND (window),
+ GDK_WINDOW_HWND (new_parent)));
+
+ API_CALL (MoveWindow, (GDK_WINDOW_HWND (window),
+ x, y, impl->width, impl->height, TRUE));
+
/* From here on, we treat parents of type GDK_WINDOW_FOREIGN like
* the root window
*/
if (GDK_WINDOW_TYPE (new_parent) == GDK_WINDOW_FOREIGN)
- new_parent = _gdk_parent_root;
+ new_parent = _gdk_root;
window_private->parent = (GdkWindowObject *)new_parent;
+ /* Switch the window type as appropriate */
+
+ switch (GDK_WINDOW_TYPE (new_parent))
+ {
+ case GDK_WINDOW_ROOT:
+ if (impl->toplevel_window_type != -1)
+ GDK_WINDOW_TYPE (window) = impl->toplevel_window_type;
+ else if (GDK_WINDOW_TYPE (window) == GDK_WINDOW_CHILD)
+ GDK_WINDOW_TYPE (window) = GDK_WINDOW_TOPLEVEL;
+ break;
+
+ case GDK_WINDOW_TOPLEVEL:
+ case GDK_WINDOW_CHILD:
+ case GDK_WINDOW_DIALOG:
+ case GDK_WINDOW_TEMP:
+ if (WINDOW_IS_TOPLEVEL (window))
+ {
+ /* Save the original window type so we can restore it if the
+ * window is reparented back to be a toplevel.
+ */
+ impl->toplevel_window_type = GDK_WINDOW_TYPE (window);
+ GDK_WINDOW_TYPE (window) = GDK_WINDOW_CHILD;
+ }
+ }
+
if (old_parent_private)
old_parent_private->children =
g_list_remove (old_parent_private->children, window);
g_return_if_fail (window == NULL || GDK_IS_WINDOW (window));
if (!window)
- window = _gdk_parent_root;
+ window = _gdk_root;
if (!GDK_WINDOW_DESTROYED (window))
{
API_CALL (GetClientRect, (GDK_WINDOW_HWND (window), &rect));
- if (window != _gdk_parent_root)
+ if (window != _gdk_root)
{
POINT pt;
GdkWindow *parent = gdk_window_get_parent (window);
rect.right = pt.x;
rect.bottom = pt.y;
- if (parent == _gdk_parent_root)
+ if (parent == _gdk_root)
{
rect.left += _gdk_offset_x;
rect.top += _gdk_offset_y;
*x = point.x;
*y = point.y;
- if (window == _gdk_parent_root)
+ if (window == _gdk_root)
{
*x += _gdk_offset_x;
*y += _gdk_offset_y;
if (hwnd == NULL)
{
- window = _gdk_parent_root;
+ window = _gdk_root;
*win_x = pointc.x + _gdk_offset_x;
*win_y = pointc.y + _gdk_offset_y;
return window;
projects / gtk4.git / commitdiff